package demo3;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Test {
    public static void main(String[] args) {
        //ArrayList是以泛型方式实现的，使用时必须要先实例化

        ArrayList<Integer> arrayList=new ArrayList<>();//这个的方法更多
        //List<Integer> list=new ArrayList<>();//向上转型

        //public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess（可随机访问）, Cloneable（可克隆）, java.io.Serializable（支持序列化）
        //ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

       // list.add(1);//默认放在最后一个位置

        //当我们调用不带参数的构造方法时，默认在第一次add的时候才会进行分配大小为10的内存！扩容是按照1.5倍进行扩容
         arrayList.add(1);
         arrayList.add(3);
         arrayList.add(2);
        arrayList.add(1);
        arrayList.add(3);
        arrayList.add(2);

         arrayList.remove(1);
         arrayList.remove(new Integer(3));


         arrayList.get(1);
         arrayList.set(0,99);

         //arrayList.clear();

         //判断1是否在顺序表中
         arrayList.contains(1);

         //截取部分 list  public List<E> subList(int fromIndex, int toIndex)
         List<Integer> list=arrayList.subList(1,3);
         list.set(0,188);
         System.out.println(list);//[188, 1]
         System.out.println(arrayList);//[99, 188, 1, 2]

        //一般情况下，能够通过sout直接输出 引用指向对象当中的内容时 此时一定重写了toString方法
        //ctrl+f 找方法
        //其父类的父类 AbstractCollection 重写了toString方法  迭代器
       /* public String toString() {
            Iterator<E> it = iterator();
            if (! it.hasNext())
                return "[]";

            StringBuilder sb = new StringBuilder();
            sb.append('[');
            for (;;) {
                E e = it.next();
                sb.append(e == this ? "(this Collection)" : e);
                if (! it.hasNext())
                    return sb.append(']').toString();
                sb.append(',').append(' ');
            }
        }*/

        /*foreach循环拿不到i下标而只能进行遍历
        for (此集合内元素类型 所定义的变量:当前要遍历的集合) {
            System.out.println(x+" ");
        }*/

        for (Integer x:list) {
            System.out.print(x+" ");
        }

        Iterator<Integer> it=list.iterator();
        while(it.hasNext()){
            System.out.print(it.next()+" ");
        }

        //用子类
        ListIterator<Integer> it2=list.listIterator();
        while(it2.hasNext()){
            System.out.print(it.next()+" ");
        }

        //倒序遍历
        ListIterator<Integer> it3=list.listIterator(list.size());
        while(it2.hasPrevious()){
            System.out.print(it3.previous()+" ");
        }
















    }
}
